/**
 * 设备列表页面
 * 功能：设备状态查看、设备管理、店铺切换
 * 作者：开发团队
 * 日期：2024
 */
const apiService = require('../../../utils/api.js');
const auth = require('../../../utils/auth.js');
const app = getApp();

Page({

	/**
	 * 页面数据
	 */
	data: {
		// ========== 系统状态 ==========
		statusBarHeight: 0, // 系统状态栏高度（动态获取）
		
		// 导航栏滚动状态
		scrollY: 0,
		navbarOpacity: 0,  // 导航栏背景透明度 (0-1)
		navbarTextColor: '#120E0C', // 导航栏文字颜色
		
		// ========== 页面来源 ==========
		isFromTab: false, // 是否来自底部 tab 切换
		
		// ========== 门店信息 ==========
		currentStore: {
			id: null,
			name: '加载中...'
		},
		storeList: [],
		
		// ========== 当前正在使用的设备 ==========
		currentUsingEquipments: [], // 从后台获取，不再使用模拟数据
		
		// ========== 设备分类选项卡 ==========
		equipmentTabs: [
			{ id: 'all', name: '全部设备', active: true },
			{ id: 'bath', name: '洗浴池', active: false },
			{ id: 'dry', name: '烘干机', active: false },
			{ id: 'blow', name: '吹风机', active: false }
		],
		currentTab: 'all', // 当前选中的设备分类
		
		// ========== 设备数据 ==========
		equipmentList: [], // 从后台实时获取
		
		// ========== 页面状态 ==========
		currentEquipmentList: [], // 当前展示的设备列表（根据选项卡筛选）
		isEmpty: false, // 是否显示空态
		isRefreshing: false, // 是否正在刷新

		// ========== 状态同步相关 ==========
		refreshInterval: null, // 状态刷新定时器
		lastUpdateTime: 0, // 最后更新时间
		// 本地倒计时定时器（每秒）
		localCountdownInterval: null
	},

	// ==================== 生命周期方法 ====================
	
	/**
	 * 页面加载
	 * @param {Object} options 页面参数
	 */
	async onLoad(options) {
		console.log('=== equipment-list 页面 onLoad ===', options);
		
		// 初始化 DataManager
		this.dataManager = app.dataManager;
		
		// 登录校验
		if (!auth.checkLoginStatus()) {
			// 未登录，直接跳转到登录页面
			auth.requireLogin();
			return;
		}
		
		this.initPage();
		
		// 加载店铺信息
		await this.loadStoreInfo();
		
		// 判断页面来源
		this.checkPageSource(options);
		
		// 加载设备数据（门店信息加载完成后）
		await this.loadEquipmentData();
		
		// 启动状态同步
		this.startStatusSync();
		
		// TODO: 根据页面参数处理业务逻辑（如传入的门店ID等）
		if (options.storeId) {
			// 处理指定门店的逻辑
			console.log('处理指定门店ID:', options.storeId);
		}
	},
	/**
	 * 页面初始化
	 */
	initPage() {
		// 获取系统信息
		const systemInfo = wx.getSystemInfoSync();
		const { statusBarHeight } = systemInfo;
		
		this.setData({
			statusBarHeight: statusBarHeight || 44
		});
		
		console.log('页面初始化完成，状态栏高度:', statusBarHeight);
	},

	/**
	 * 检查页面来源
	 * @param {Object} options 页面参数
	 */
	checkPageSource(options) {
		// 获取页面栈信息
		const pages = getCurrentPages();
		const currentPageIndex = pages.length - 1;
		
		// 判断是否来自 tab 切换
		// 如果页面栈中只有当前页面，或者当前页面是首页，则认为是来自 tab 切换
		let isFromTab = false;
		
		if (pages.length === 1) {
			// 只有一个页面，说明是直接打开或来自 tab
			isFromTab = true;
		} else {
			// 检查前一个页面是否是 tab 页面
			const previousPage = pages[currentPageIndex - 1];
			const tabPages = [
				'pages/home/index/index',
				'pages/booking/equipment-list/index',
				'pages/main/pet-care/index',
				'pages/user/profile/index'
			];
			
			if (previousPage && tabPages.includes(previousPage.route)) {
				isFromTab = true;
			}
		}
		
		// 如果页面参数中有特殊标记，说明是从其他页面跳转过来的
		if (options.extendSuccess || options.equipmentId || options.storeId) {
			isFromTab = false;
		}
		
		this.setData({
			isFromTab
		});
		
		console.log('页面来源判断:', { isFromTab, pageStackLength: pages.length, options });
	},

	/**
	 * 筛选设备列表
	 * 根据当前选中的分类，筛选要显示的设备
	 */
	filterEquipmentList() {
		const { currentTab, equipmentList } = this.data;
		
		let filteredList = [];
		
		// 首先过滤掉门禁设备（双重保障，后端已过滤）
		const nonAccessDevices = equipmentList.filter(equipment => {
			const t = String(equipment.type || '').toLowerCase();
			return !(t.includes('access')); // 过滤 access / access_control
		});
		
		if (currentTab === 'all') {
			filteredList = [...nonAccessDevices];
		} else {
			filteredList = nonAccessDevices.filter(equipment => equipment.type === currentTab);
		}
		
		this.setData({
			currentEquipmentList: filteredList,
			isEmpty: filteredList.length === 0
		});
		
		console.log('设备列表筛选完成:', { currentTab, filteredCount: filteredList.length });
	},

	/**
	 * 启动状态同步
	 */
	startStatusSync() {
		this.stopStatusSync(); // 先停止之前的同步
		
		// 每20秒同步一次状态（更及时）
		this.data.refreshInterval = setInterval(() => {
			this.syncDeviceStatus();
		}, 20000);
		
		console.log('启动设备状态同步');
	},

	/**
	 * 同步设备状态
	 */
	async syncDeviceStatus() {
		if (!this.data.currentStore.id) {
			return;
		}
		
		try {
			console.log('同步设备状态...');
			
			// 调用API获取最新设备状态
			const result = await apiService.getStoreDevicesRealTimeStatus(this.data.currentStore.id);
			console.log('=== 同步设备状态 - API返回结果 ===');
			console.log('result.success:', result.success);
			console.log('result.data类型:', typeof result.data);
			console.log('result.data是否为数组:', Array.isArray(result.data));
			console.log('result.data内容:', result.data);
			
			if (result.success) {
				// 检查返回数据格式
				const deviceData = result.data || [];
				console.log('syncDeviceStatus - deviceData类型检查:', {
					deviceData,
					typeof: typeof deviceData,
					isArray: Array.isArray(deviceData)
				});
				
				if (!Array.isArray(deviceData)) {
					console.error('同步设备状态 - API返回的数据不是数组格式:', {
						deviceData,
						typeof: typeof deviceData,
						isArray: Array.isArray(deviceData),
						originalResult: result
					});
					return;
				}
				
				// 转换设备数据格式（remainingTime 统一按秒）
				const nowMs = Date.now();
				// 获取当前用户ID
				const currentUserId = auth.getCurrentUser().userId;
				
				const equipmentList = deviceData.map(device => {
					// 使用 endTime(毫秒) 优先推算剩余秒数，避免单位误差
					const nowMs = Date.now();
					const endTimeMs = device.endTime || 0;
					let remainingSeconds = 0;
					if (endTimeMs && endTimeMs > nowMs) {
						remainingSeconds = Math.max(0, Math.floor((endTimeMs - nowMs) / 1000));
					} else {
						const rtRaw = Number(device.remainingTime) || 0;
						// 兜底：若后端历史上误以毫秒返回，这里做一次自动纠正（大值按毫秒转秒）
						remainingSeconds = rtRaw > 86400 ? Math.floor(rtRaw / 1000) : rtRaw;
					}
					const statusStr = this.convertDeviceStatus(device.status);
					// 强制保险：空闲状态下剩余时间强制置0，避免误判
					if (statusStr === 'free') {
						remainingSeconds = 0;
					}
				const isMyDevice = device.currentUserId === currentUserId;
					const icons = this.resolveEquipmentIcons(device.type);
					return {
						id: device._id,
						type: device.type,
						name: device.name,
						status: statusStr,
						remainingTime: remainingSeconds, // 统一为秒
						image: device.icon || icons.image,
						imageOn: icons.imageOn,
						imageUsing: icons.imageUsing,
						iotId: device.iotId,
						isOnline: device.isOnline || false,
						switchStatus: device.switchStatus || false,
						currentTemperature: device.currentTemperature || 0,
						waterLevel: device.waterLevel || 0,
						currentOrderId: device.currentOrderId || null,
						currentUserId: device.currentUserId || null, // 添加当前使用设备的用户ID
						isMyDevice: isMyDevice, // 标记是否为当前用户的设备
						startTime: device.startTime || 0 // 添加订单开始时间用于排序
					};
				});
				
				// 筛选出正在使用的设备，并排序：
				// 1. 用户自己的设备优先（从左到右）
				// 2. 其他用户的设备按启用时间排序（从左到右）
				console.log('syncDeviceStatus - 排序前 - currentUserId:', currentUserId, '设备列表:', equipmentList.filter(e => e.status === 'using').map(e => ({ name: e.name, currentUserId: e.currentUserId, isMyDevice: e.isMyDevice })));
				const currentUsingEquipments = equipmentList
					.filter(equipment => equipment.status === 'using')
					.sort((a, b) => {
						// 确保类型一致（都转为字符串比较）
						const aUserId = String(a.currentUserId || '');
						const bUserId = String(b.currentUserId || '');
						const currentUserIdStr = String(currentUserId || '');
						
						const aIsMine = aUserId === currentUserIdStr && aUserId !== '';
						const bIsMine = bUserId === currentUserIdStr && bUserId !== '';
						
						// 如果一个是自己的，一个是别人的，自己的优先
						if (aIsMine && !bIsMine) return -1;
						if (!aIsMine && bIsMine) return 1;
						
						// 如果都是自己的或都是别人的，按开始时间排序（最早的在前）
						return (a.startTime || 0) - (b.startTime || 0);
					});
				console.log('syncDeviceStatus - 排序后 - 设备列表:', currentUsingEquipments.map(e => ({ name: e.name, currentUserId: e.currentUserId, isMyDevice: e.isMyDevice })));
				
				this.setData({
					equipmentList: equipmentList,
					currentUsingEquipments: currentUsingEquipments,
					lastUpdateTime: Date.now()
				});
				
				// 重新筛选设备列表
				this.filterEquipmentList();
				
				// 确保本地倒计时在同步后继续运行
				this.startLocalCountdown();
				
				console.log('设备状态同步完成');
			}
		} catch (error) {
			console.error('同步设备状态失败:', error);
		}
	},

	/**
	 * 停止状态同步
	 */
	stopStatusSync() {
		if (this.data.refreshInterval) {
			clearInterval(this.data.refreshInterval);
			this.setData({
				refreshInterval: null
			});
			console.log('停止设备状态同步');
		}
		// 额外：清理本地倒计时定时器
		if (this.data.localCountdownInterval) {
			clearInterval(this.data.localCountdownInterval);
			this.setData({
				localCountdownInterval: null
			});
			console.log('停止本地倒计时');
		}
	},



	// ==================== 事件处理方法 ====================

	/**
	 * 返回上一页
	 */
	onBack() {
		console.log('=== 点击返回按钮 ===', { isFromTab: this.data.isFromTab });
		
		if (this.data.isFromTab) {
			// 来自 tab 切换，返回首页
			wx.switchTab({
				url: '/pages/home/index/index',
				success: () => {
					console.log('从设备页面返回首页成功');
				},
				fail: (error) => {
					console.error('返回首页失败：', error);
					// 降级处理：使用 navigateBack
					wx.navigateBack({
						delta: 1,
						fail: () => {
							console.error('navigateBack 也失败了');
						}
					});
				}
			});
		} else {
			// 来自其他页面跳转，返回上一页
			wx.navigateBack({
				delta: 1,
				success: () => {
					console.log('返回上一页成功');
				},
				fail: (error) => {
					console.error('返回上一页失败：', error);
					// 如果返回失败，跳转到首页
					wx.switchTab({
						url: '/pages/home/index/index'
					});
				}
			});
		}
	},

	/**
	 * 店铺切换
	 */
	onStoreChange() {
		console.log('=== 点击切换店铺 ===');
		// 直接跳转到地址选择页面
		wx.navigateTo({
			url: '/pages/booking/select-address/index',
			success: () => {
				console.log('跳转到地址选择页面成功');
			},
			fail: (error) => {
				console.error('跳转到地址选择页面失败：', error);
				// 降级处理：显示门店选择ActionSheet
				this.showStoreActionSheet();
			}
		});
	},

	/**
	 * 加载店铺信息
	 */
	async loadStoreInfo() {
		try {
			const app = getApp();
			const storeManager = app.getStoreManager();
			
			// 1. 优先检查首页是否已经获取了门店信息
			let selectedStore = null;
			
			// 从首页获取当前门店信息
			const pages = getCurrentPages();
			const homePage = pages.find(page => page.route === 'pages/home/index/index');
			if (homePage && homePage.data && homePage.data.currentStore && homePage.data.currentStore.name !== '加载中...') {
				selectedStore = homePage.data.currentStore;
				console.log('从首页获取到门店信息:', selectedStore);
			}
			
			// 2. 如果首页没有门店信息，尝试使用门店管理器获取最近的门店
			if (!selectedStore) {
				try {
					selectedStore = await storeManager.getNearestStore();
					console.log('从门店管理器获取到最近门店:', selectedStore);
				} catch (error) {
					console.log('获取最近门店失败:', error);
				}
			}
			
			// 3. 获取完整的门店列表
			const storeList = await storeManager.getStoreList();
			
			if (storeList && storeList.length > 0) {
				// 如果有选中的门店，验证它是否在门店列表中
				let currentStore = null;
				if (selectedStore) {
					currentStore = storeList.find(store => 
						store._id === selectedStore._id || 
						store._id === selectedStore.id ||
						store.storeId === selectedStore.storeId
					);
				}
				
				// 如果没有找到匹配的门店，使用第一个门店
				if (!currentStore) {
					currentStore = storeList[0];
					console.log('使用默认第一个门店:', currentStore);
				}
				
				this.setData({
					storeList: storeList,
					currentStore: {
						id: currentStore._id,
						name: currentStore.name
					}
				});
			} else {
				// 降级处理：使用默认店铺信息
				this.setData({
					currentStore: {
						id: 'store_001',
						name: '超级泡泡宠物店'
					},
					storeList: [{
						_id: 'store_001',
						name: '超级泡泡宠物店'
					}]
				});
			}
		} catch (error) {
			console.error('加载店铺信息失败:', error);
			// 降级处理：使用默认店铺信息
			this.setData({
				currentStore: {
					id: 'store_001',
					name: '超级泡泡宠物店'
				},
				storeList: [{
					_id: 'store_001',
					name: '超级泡泡宠物店'
				}]
			});
		}
	},

	/**
	 * 显示店铺选择器
	 */
	showStoreActionSheet() {
		const { storeList, currentStore } = this.data;
		
		if (storeList.length === 0) {
			wx.showToast({
				title: '暂无店铺信息',
				icon: 'none'
			});
			return;
		}
		
		wx.showActionSheet({
			itemList: storeList.map(store => store.name),
			success: (res) => {
				const selectedStore = storeList[res.tapIndex];
				if (selectedStore._id !== currentStore.id) {
					this.setData({
						currentStore: {
							id: selectedStore._id,
							name: selectedStore.name
						}
					});
					
					// 切换店铺后重新加载数据
					this.loadEquipmentData();
					
					console.log('切换店铺:', selectedStore);
					wx.showToast({
						title: `已切换到${selectedStore.name}`,
						icon: 'success'
					});
				}
			},
			fail: (err) => {
				console.log('取消选择店铺:', err);
			}
		});
	},

	/**
	 * 设备分类切换
	 * @param {Object} e 事件对象
	 */
	onTabChange(e) {
		const { tab } = e.currentTarget.dataset;
		
		if (tab === this.data.currentTab) {
			return; // 如果点击的是当前选中的分类，不做处理
		}
		
		console.log('=== 切换设备分类 ===', tab);
		
		// 更新选中状态
		const equipmentTabs = this.data.equipmentTabs.map(tabItem => ({
			...tabItem,
			active: tabItem.id === tab
		}));
		
		this.setData({
			currentTab: tab,
			equipmentTabs
		});
		
		// 重新筛选设备列表
		this.filterEquipmentList();
	},

	/**
	 * 设备卡片点击
	 * @param {Object} e 事件对象
	 */
	onEquipmentTap(e) {
		const { equipment } = e.currentTarget.dataset;
		
		console.log('=== 点击设备卡片 ===', equipment);
		
		if (equipment.status === 'free') {
			// 设备可用，跳转到设备详情或启动使用流程
			wx.showModal({
				title: '启动设备',
				content: `确定要使用${equipment.name}吗？`,
				success: (res) => {
					if (res.confirm) {
						this.startUsingEquipment(equipment);
					}
				}
			});
		} else if (equipment.status === 'using') {
			// 设备使用中，可以查看详情或进行管理操作
			wx.showToast({
				title: '设备使用中',
				icon: 'none'
			});
		} else {
			// 设备维护中
			wx.showToast({
				title: '设备当前不可用',
				icon: 'none'
			});
		}
	},

	/**
	 * 延时按钮点击
	 * @param {Object} e 事件对象
	 */
	onExtendTime(e) {
		const { equipment } = e.currentTarget.dataset;
		
		console.log('=== 点击延时按钮 ===', equipment);
		
		// 构造跳转到时长选择页面的设备数据
		const equipmentData = {
			...equipment,
			isExtending: true, // 标记这是延时操作
			currentOrderId: equipment.currentOrderId || `mock_order_${equipment.id}` // 当前订单ID，用于延时订单关联
		};
		
		// 将设备数据序列化为 URL 参数
		const equipmentDataStr = encodeURIComponent(JSON.stringify(equipmentData));
		
		// 跳转到时长选择页面
		wx.navigateTo({
			url: `/pages/booking/select-duration/index?equipmentData=${equipmentDataStr}`,
			success: () => {
				console.log('跳转到时长选择页面成功');
			},
			fail: (error) => {
				console.error('跳转到时长选择页面失败：', error);
				wx.showToast({
					title: '跳转失败，请重试',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 结束使用按钮点击
	 * @param {Object} e 事件对象
	 */
	onEndUsing(e) {
		const { equipment } = e.currentTarget.dataset;
		
		console.log('=== 点击结束使用按钮 ===', equipment);
		
		wx.showModal({
			title: '结束使用',
			content: `确认结束使用${equipment.name}吗？`,
			success: (res) => {
				if (res.confirm) {
					this.endUsingEquipment(equipment);
				}
			}
		});
	},

	/**
	 * 开始使用设备
	 * @param {Object} equipment 设备信息
	 */
	async startUsingEquipment(equipment) {
		// 跳转到时长选择页面，让用户选择使用时长
		const equipmentData = {
			...equipment,
			isExtending: false // 标记这是新的使用，不是延时
		};
		
		// 将设备数据序列化为 URL 参数
		const equipmentDataStr = encodeURIComponent(JSON.stringify(equipmentData));
		
		// 跳转到时长选择页面
		wx.navigateTo({
			url: `/pages/booking/select-duration/index?equipmentData=${equipmentDataStr}`,
			success: () => {
				console.log('跳转到时长选择页面成功');
			},
			fail: (error) => {
				console.error('跳转到时长选择页面失败：', error);
				wx.showToast({
					title: '跳转失败，请重试',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 结束使用设备
	 * @param {Object} equipment 设备信息
	 */
	async endUsingEquipment(equipment) {
		try {
			wx.showLoading({ title: '关闭设备中...' });
			
			// 调用API控制设备关闭
			const result = await apiService.controlDevice(equipment.id, 'off');
			
			if (result.success) {
				// 从正在使用列表中移除
				const updatedUsingEquipments = this.data.currentUsingEquipments.filter(item => item.id !== equipment.id);
				
				this.setData({
					currentUsingEquipments: updatedUsingEquipments
				});
				
				// 更新设备状态为空闲
				const updatedEquipmentList = this.data.equipmentList.map(item => {
					if (item.id === equipment.id) {
						return {
							...item,
							status: 'free',
							switchStatus: false,
							remainingTime: 0
						};
					}
					return item;
				});
				
				this.setData({
					equipmentList: updatedEquipmentList
				});
				
				// 重新筛选设备列表
				this.filterEquipmentList();
				
				wx.showToast({
					title: '使用结束',
					icon: 'success'
				});
			} else {
				wx.showToast({
					title: result.message || '关闭设备失败',
					icon: 'none'
				});
			}
		} catch (error) {
			console.error('关闭设备异常:', error);
			wx.showToast({
				title: '网络异常，请重试',
				icon: 'none'
			});
		} finally {
			wx.hideLoading();
		}
	},

	/**
	 * 检查是否有新选择的门店
	 */
	checkSelectedStore() {
		try {
			const app = getApp();
			if (app.globalData && app.globalData.selectedStore) {
				const selectedStore = app.globalData.selectedStore;
				console.log('检测到新选择的门店:', selectedStore);
				
				// 更新页面显示的门店信息
				this.setData({
					currentStore: {
						id: selectedStore._id,
						name: selectedStore.name
					}
				});
				
				// 清除全局数据，避免重复处理
				app.globalData.selectedStore = null;
				
				// 重新加载设备数据（因为门店已切换）
				this.loadEquipmentData();
				
				console.log('门店信息已更新，重新加载设备数据');
			}
		} catch (error) {
			console.error('检查选择门店失败：', error);
		}
	},

	/**
	 * 同步门店信息
	 * 确保页面显示时能获取到正确的门店信息
	 */
	async syncStoreInfo() {
		try {
			// 如果当前门店信息为空或显示"加载中..."，则重新加载门店信息
			if (!this.data.currentStore.id || this.data.currentStore.name === '加载中...') {
				console.log('门店信息为空，重新加载门店信息');
				await this.loadStoreInfo();
			} else {
				// 检查首页是否有更新的门店信息
				const pages = getCurrentPages();
				const homePage = pages.find(page => page.route === 'pages/home/index/index');
				if (homePage && homePage.data && homePage.data.currentStore) {
					const homeStore = homePage.data.currentStore;
					// 如果首页的门店信息与当前页面不同，且首页门店信息有效，则同步
					if (homeStore.name !== '加载中...' && 
						(homeStore.id !== this.data.currentStore.id || homeStore.name !== this.data.currentStore.name)) {
						console.log('同步首页门店信息:', homeStore);
						this.setData({
							currentStore: {
								id: homeStore.id || homeStore._id,
								name: homeStore.name
							}
						});
					}
				}
			}
		} catch (error) {
			console.error('同步门店信息失败:', error);
		}
	},

	/**
	 * 检查延时操作结果
	 */
	checkExtendResult() {
		// 检查页面参数中是否有延时成功的标记
		const pages = getCurrentPages();
		const currentPage = pages[pages.length - 1];
		const options = currentPage.options || {};
		
		if (options.extendSuccess === 'true' && options.equipmentId) {
			// 找到对应的设备并增加延时时间
			const equipmentId = String(options.equipmentId); // 设备ID使用字符串，避免 parseInt 导致 NaN
			// 统一单位：options.extendTime 为分钟，这里转换为秒
			const extendMinutesRaw = options.extendTime;
			const extendMinutes = extendMinutesRaw != null ? Number(extendMinutesRaw) : 0;
			const extendSeconds = isNaN(extendMinutes) ? 0 : extendMinutes * 60;
			
			if (extendSeconds > 0) {
				// 更新正在使用的设备的剩余时间（按秒）
				const updatedUsingEquipments = this.data.currentUsingEquipments.map(item => {
				    if (String(item.id) === equipmentId) {
				        item.remainingTime += extendSeconds;
				    }
				    return item;
				});
				
				this.setData({
				    currentUsingEquipments: updatedUsingEquipments
				});
				
				// 同步更新设备总列表
				const updatedEquipmentList = this.data.equipmentList.map(item => {
				    if (String(item.id) === equipmentId) {
				        item.remainingTime += extendSeconds;
				    }
				    return item;
				});
				
				this.setData({
				    equipmentList: updatedEquipmentList
				});
				
				this.filterEquipmentList();
				
				// 延时后确保本地倒计时继续运行
				this.startLocalCountdown();
				console.log(`设备 ${equipmentId} 延时 ${extendMinutes} 分钟成功（+${extendSeconds} 秒）`);
			} else {
				console.warn('延时参数缺失或无效：', options.extendTime);
			}
		}
	},

	/**
	 * 加载设备数据
	 */
	async loadEquipmentData() {
		console.log('=== 加载设备数据 ===');
		console.log('当前门店信息:', this.data.currentStore);
		
		if (!this.data.currentStore.id) {
			console.log('门店ID为空，无法加载设备数据');
			return;
		}
		
		try {
			this.setData({ isRefreshing: true });
			
			// 调用API获取设备实时状态
			console.log('调用API获取设备状态，门店ID:', this.data.currentStore.id);
			const result = await apiService.getStoreDevicesRealTimeStatus(this.data.currentStore.id);
			
			if (result.success) {
				// 检查返回数据格式
				const deviceData = result.data || [];	
				if (!Array.isArray(deviceData)) {
					console.error('API返回的数据不是数组格式:', {
						deviceData,
						typeof: typeof deviceData,
						isArray: Array.isArray(deviceData),
						originalResult: result
					});
					wx.showToast({
						title: '数据格式错误',
						icon: 'none'
					});
					return;
				}
				
				// 获取当前用户ID（在map之前获取，以便在map中使用）
				const currentUserId = auth.getCurrentUser().userId;
				
				// 转换设备数据格式
				const nowMs = Date.now();
				const equipmentList = deviceData.map(device => {
					const endTimeMs = device.endTime || 0;
					let remainingSeconds = 0;
					if (endTimeMs && endTimeMs > nowMs) {
						remainingSeconds = Math.max(0, Math.floor((endTimeMs - nowMs) / 1000));
					} else {
						const rtRaw = Number(device.remainingTime) || 0;
						// 兜底：若历史上误以毫秒返回，这里自动纠正（按毫秒转秒）
						remainingSeconds = rtRaw > 86400 ? Math.floor(rtRaw / 1000) : rtRaw;
					}
					const statusStr = this.convertDeviceStatus(device.status);
					// 强制保险：空闲状态下剩余时间强制置0，避免误判
					if (statusStr === 'free') {
						remainingSeconds = 0;
					}
					const isMyDevice = device.currentUserId === currentUserId;
					const icons = this.resolveEquipmentIcons(device.type);
					return {
						id: device._id,
						type: device.type,
						name: device.name,
						status: statusStr,
						remainingTime: remainingSeconds,
						image: device.icon || icons.image,
						imageOn: icons.imageOn,
						imageUsing: icons.imageUsing,
						iotId: device.iotId,
						isOnline: device.isOnline || false,
						switchStatus: device.switchStatus || false,
						currentTemperature: device.currentTemperature || 0,
						waterLevel: device.waterLevel || 0,
						currentOrderId: device.currentOrderId || null,
						currentUserId: device.currentUserId || null, // 添加当前使用设备的用户ID
						isMyDevice: isMyDevice, // 标记是否为当前用户的设备
						startTime: device.startTime || 0 // 添加订单开始时间用于排序
					};
				});
				
				// 筛选出正在使用的设备，并排序：
				// 1. 用户自己的设备优先（从左到右）
				// 2. 其他用户的设备按启用时间排序（从左到右）
				console.log('loadEquipmentData - 排序前 - currentUserId:', currentUserId, '设备列表:', equipmentList.filter(e => e.status === 'using').map(e => ({ name: e.name, currentUserId: e.currentUserId, isMyDevice: e.isMyDevice })));
				const currentUsingEquipments = equipmentList
					.filter(equipment => equipment.status === 'using')
					.sort((a, b) => {
						// 确保类型一致（都转为字符串比较）
						const aUserId = String(a.currentUserId || '');
						const bUserId = String(b.currentUserId || '');
						const currentUserIdStr = String(currentUserId || '');
						
						const aIsMine = aUserId === currentUserIdStr && aUserId !== '';
						const bIsMine = bUserId === currentUserIdStr && bUserId !== '';
						
						// 如果一个是自己的，一个是别人的，自己的优先
						if (aIsMine && !bIsMine) return -1;
						if (!aIsMine && bIsMine) return 1;
						
						// 如果都是自己的或都是别人的，按开始时间排序（最早的在前）
						return (a.startTime || 0) - (b.startTime || 0);
					});
				console.log('loadEquipmentData - 排序后 - 设备列表:', currentUsingEquipments.map(e => ({ name: e.name, currentUserId: e.currentUserId, isMyDevice: e.isMyDevice })));
					
				this.setData({
					equipmentList: equipmentList,
					currentUsingEquipments: currentUsingEquipments
				});
			
			console.log('设备数据加载完成:', {
				total: equipmentList.length,
				using: currentUsingEquipments.length
			});
			
			// 重新筛选设备列表
			this.filterEquipmentList();
			} else {
				console.error('获取设备列表失败:', result.message);
				wx.showToast({
					title: result.message || '获取设备列表失败',
					icon: 'none'
				});
			}
		} catch (error) {
			console.error('加载设备数据异常:', error);
			wx.showToast({
				title: '网络异常，请重试',
				icon: 'none'
			});
		} finally {
			this.setData({ isRefreshing: false });
			wx.stopPullDownRefresh();
		}
	},

	/**
	 * 转换设备状态
	 * @param {number|string} status 数据库中的设备状态
	 * @returns {string} 页面使用的设备状态
	 */
		convertDeviceStatus(status) {
		// 后端返回的状态：数字格式 0=维修中, 1=可用, 2=使用中
		// 前端需要的状态：字符串格式 free(空闲), using(使用中), maintenance(维护中)
		
		// 处理数字状态值
		if (typeof status === 'number') {
			const statusMap = {
				0: 'maintenance', // 维修中
				1: 'free',        // 可用/空闲
				2: 'using'        // 使用中
			};
			return statusMap[status] || 'free';
		}
		
		// 兼容旧的字符串状态值
		const stringStatusMap = {
			'free': 'free',
			'using': 'using',
			'maintenance': 'maintenance',
			'offline': 'maintenance',
			'idle': 'free',
			'running': 'using'
		};
			return stringStatusMap[status] || 'free';
		},

		resolveIconBase(type) {
			const t = String(type || '').toLowerCase();
			if (t.includes('blow')) return 'icon_hair_dryer';
			if (t.includes('dry')) return 'icon_dryer';
			if (t.includes('bath')) return 'icon_bath';
			if (t.includes('room')) return 'icon_private_room';
			if (t.includes('access')) return 'icon_access';
			return 'icon_default';
		},

		resolveEquipmentIcons(type) {
			const base = this.resolveIconBase(type);
			const image = `/assets/equipment-list/${base}.png`;
			const imageOn = (base === 'icon_default' || base === 'icon_access') ? image : `/assets/equipment-list/${base}_on.png`;
			const imageUsing = base === 'icon_default' ? '/assets/equipment-list/icon_default_use.png' : `/assets/equipment-list/${base}_use.png`;
			// console.log('resolveEquipmentIcons - 图标路径:', { type, base, image, imageOn, imageUsing });
			return { image, imageOn, imageUsing };
		},

	// ==================== 页面生命周期 ====================

	/**
	 * 页面初次渲染完成
	 */
	onReady() {
		console.log('=== equipment-list 页面 onReady ===');
	},

	/**
	 * 页面显示
	 */
	onShow() {
		console.log('=== equipment-list 页面 onShow ===');
		
		// 登录校验
		if (!auth.checkLoginStatus()) {
			// 未登录，直接跳转到登录页面
			auth.requireLogin();
			return;
		}
		
		// 同步TabBar状态（优化版本）
		this.updateTabBarStatus(1);
		
		// 检查是否有新选择的门店
		this.checkSelectedStore();
		
		// 同步门店信息 - 确保首次登录时能获取到正确的门店信息
		this.syncStoreInfo();
		
		// 检查是否有延时操作的结果需要处理
		this.checkExtendResult();
		
		// 页面显示时重新加载数据
		this.loadEquipmentData();
		// 启动状态同步
		this.startStatusSync();
		
		// 启动本地倒计时（每秒）
		this.startLocalCountdown();
		// 立即同步一次设备状态，确保获取最新数据
		setTimeout(() => {
			this.syncDeviceStatus();
		}, 500);
	},

	/**
	 * 页面隐藏
	 */
	onHide() {
		console.log('=== equipment-list 页面 onHide ===');
		// 停止状态同步
		this.stopStatusSync();
	},

	/**
	 * 页面卸载
	 */
	onUnload() {
		console.log('=== equipment-list 页面 onUnload ===');
		// 页面卸载时清理资源
		this.stopStatusSync();
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {
		console.log('=== 下拉刷新 ===');
		this.setData({
			isRefreshing: true
		});
		this.loadEquipmentData();
	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {
		console.log('=== 上拉触底 ===');
		// TODO: 如果有分页，在这里加载更多数据
	},

	/**
	 * 页面滚动监听
	 */
	onPageScroll(e) {
		const scrollY = e.scrollTop;
		
		// 计算导航栏背景透明度，滚动距离0-100px内从透明变为不透明
		const maxScrollDistance = 100; // 滚动距离阈值（像素）
		const opacity = Math.min(scrollY / maxScrollDistance, 1);
		
		// 计算文字颜色，透明度达到0.5时开始变黑
		const textColor = opacity >= 0.5 ? '#120E0C' : '#120E0C';
		
		// 只有在透明度或文字颜色发生变化时才更新
		if (this.data.navbarOpacity !== opacity || this.data.navbarTextColor !== textColor) {
			this.setData({
				scrollY: scrollY,
				navbarOpacity: opacity,
				navbarTextColor: textColor
			});
		}
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {
		return {
			title: '设备列表',
			path: '/pages/main/equipment-list/index'
		};
	},

	/**
	 * 清除所有定时器（保留兼容性）
	 */
	clearAllTimers() {
		// 现在由stopStatusSync处理，保留此方法以兼容其他调用
		this.stopStatusSync();
	},
	// 启动本地倒计时（每秒刷新剩余时间）
	startLocalCountdown() {
		// 先停止已有倒计时
		if (this.data.localCountdownInterval) {
			clearInterval(this.data.localCountdownInterval);
		}
		this.data.localCountdownInterval = setInterval(() => {
			const equipmentList = Array.isArray(this.data.equipmentList) ? this.data.equipmentList : [];
			// 只对使用中的设备进行倒计时
			const updatedEquipmentList = equipmentList.map(item => {
				if (item && item.status === 'using') {
					const rt = Number(item.remainingTime) || 0;
					const newRT = rt > 0 ? rt - 1 : 0;
					return Object.assign({}, item, { remainingTime: newRT });
				}
				return item;
			});
			const currentUsingEquipments = updatedEquipmentList.filter(e => e && e.status === 'using');
			this.setData({
				equipmentList: updatedEquipmentList,
				currentUsingEquipments: currentUsingEquipments
			});
		}, 1000);
		console.log('启动本地倒计时');
	},

	/**
	 * 更新TabBar状态的统一方法
	 * @param {number} selectedIndex TabBar选中索引
	 */
	updateTabBarStatus(selectedIndex) {
		console.log(`设备列表页面更新TabBar状态: ${selectedIndex}`);
		
		if (typeof this.getTabBar === 'function') {
			// 多重保障的TabBar状态更新
			try {
				const tabBar = this.getTabBar();
				if (tabBar) {
					// 传统模式
					console.log('传统模式更新TabBar');
					if (tabBar.setSelected) {
						tabBar.setSelected(selectedIndex);
					} else {
						tabBar.setData({ selected: selectedIndex });
					}
				} else {
					// skyline模式 - 异步回调
					console.log('Skyline模式异步更新TabBar');
					this.getTabBar((tabBar) => {
						if (tabBar) {
							if (tabBar.setSelected) {
								tabBar.setSelected(selectedIndex);
							} else {
								tabBar.setData({ selected: selectedIndex });
							}
						}
					});
				}
			} catch (error) {
				console.error('TabBar状态更新失败:', error);
				// 降级处理：尝试异步调用
				try {
					this.getTabBar((tabBar) => {
						if (tabBar) {
							if (tabBar.setSelected) {
								tabBar.setSelected(selectedIndex);
							} else {
								tabBar.setData({ selected: selectedIndex });
							}
						}
					});
				} catch (asyncError) {
					console.error('TabBar异步更新也失败:', asyncError);
				}
			}
		} else {
			console.warn('getTabBar方法不可用');
		}
	}
});
